home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / STUTTGART / UTIL / MEMORY / OLD / MEM208SRC / !Memphis / c / memcore < prev    next >
Text File  |  1993-09-08  |  21KB  |  823 lines
  1. /*
  2.  * memcore.c
  3.  * Part of the !Memphis distribution
  4.  * (c) bdb/nas, 1991-3
  5.  */
  6.  
  7. /* compile with -dPUFFS for alternate */
  8. /* #define DEBUG */
  9. #include "FS.h"
  10. /*  debug support*/
  11. #ifdef DEBUG
  12. #define DEBUGf printf
  13. #else
  14. #define DEBUGf 1?(void)0:(void)printf
  15. #endif
  16.  
  17.  
  18.  
  19. #ifndef PUFFS
  20. #define MEMFS
  21. #endif
  22.  
  23. #ifdef MEMFS
  24. #define FSNUM 91  /* Acorn-allocated */
  25. #else
  26. #define FSNUM 0xF0
  27. #endif
  28.  
  29. #define FSERR ( (0x100+FSNUM)<<8 )
  30.  
  31. static DEFERR( mb_Lostinode,           FSERR+0xAC,  "inode lost" );
  32. static DEFERR( mb_malloc_failed,       FSERR,       "Not enough free memory" );
  33. static DEFERR( mb_Locked,              FSERR+0xC3,  "Locked" );
  34. static DEFERR( mb_DirNotEmpty,         FSERR+0xB4,  "Directory Not Empty" );
  35. static DEFERR( mb_ObjectInUse,         FSERR+8,     "Object in use" );
  36. static DEFERR( mb_LongName,            FSERR+0xCC,  "FileName too long" );
  37. static DEFERR( mb_NotADir,             FSERR+0xC5,  "Not a Directory" );
  38. static DEFERR( mb_NotAFile,            FSERR+0xC5,  "Not a File" );
  39. static DEFERR( mb_AlreadyExists,       FSERR+0xC4,  "Already exists" );
  40. static DEFERR( mb_BadRename,           FSERR+0x9F,  "Not same disc" );
  41. static DEFERR( mb_enddir,              FSERR,       "Read off end of directory" );
  42. #ifdef MEMFS
  43. char FilingSystemName[]="Mem";
  44. char ModuleName[]="MemFS";
  45. int FilingSystemInformationWord=0x8B800000 + FSNUM;
  46. #else
  47. char FilingSystemName[]="Puf";
  48. char ModuleName[]="PUFFS";
  49. int FilingSystemInformationWord=0x8B800000 + FSNUM;
  50. #endif
  51.  
  52. #define FILENAMELEN 30
  53.  
  54. #ifdef DEBUG
  55. #define DEBUGF printf
  56. #else
  57. #define DEBUGF 1?(void)0:(void)printf
  58. #endif
  59.  
  60. #include "store.h"
  61. #include "inode.h"
  62.  
  63. /*  Event stuff */
  64. #include "ticker.h"
  65.  
  66. int tickerperiod = 100 ; /* centiseconds */
  67.  
  68. int enableticking = 1;
  69.  
  70. void ticker(void)
  71. { Inode_Ticker();
  72. }
  73.  
  74. /*  Directory module */
  75. /*
  76.  *
  77.  * Directory structure:
  78.  *
  79.  * Directory pointer is a char *
  80.  * Each entry has a 4 byte inode, followed by a name, NUL-terminated.
  81.  */
  82. #define DINODE( x ) ( *( int * )x->pos )
  83. #define DNAME( x ) ( (x->pos)+4 )
  84. #define DLEN( x ) (~3&8+x)
  85. #define DMORE( x ) (x->pos)
  86.  
  87. #define DIRPAGESIZE 512         /* directories come in pages of this size */
  88. #define DIRPAGEMARK -3          /* DINODE set to this for no more on this page */
  89.  
  90. typedef struct DIR
  91. { char buf[DIRPAGESIZE];
  92.   char *pos;            /* pointer into dirbuf for current elt */
  93.   int off;              /* offset of current page in directory */
  94.   int len;              /* total length of directory */
  95.   INODE *inode;
  96. } DIR;
  97.  
  98. static DIR *dir_open(INODE *h)
  99. { DIR *p;
  100.   p = malloc(sizeof(DIR));
  101.   if (!p)
  102.     return NULL;
  103.   DEBUGf("dir_open(%d)=%p\n",h->inode,p);
  104.   p->inode = Inode_Dup(h);
  105.   p->len = h->d.length;
  106.   p->off = 0;
  107.   if (p->len && !Inode_Read( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf ))
  108.     p->pos = p->buf;
  109.   else
  110.     p->pos = NULL;
  111.   return p;
  112. }
  113.  
  114. static _kernel_oserror *dir_close(DIR *p)
  115. {
  116.   DEBUGf("dir_close(%p)\n",p);
  117.   if (p)
  118.   { Inode_Lose(p->inode);
  119.     free(p);
  120.   }
  121.   return NULL;
  122. }
  123.  
  124. static _kernel_oserror *dir_next( DIR *p )
  125. { _kernel_oserror *err;
  126.   DEBUGf("dir_next(%p)\n",p);
  127.   if (!p->pos)
  128.     return ERR(mb_enddir);
  129.   p->pos+=DLEN(strlen(DNAME(p)));
  130.   if (p->pos-p->buf>=p->len-p->off)
  131.     p->pos = NULL;
  132.   else if (DINODE(p)==DIRPAGEMARK)
  133.   { p->off+=DIRPAGESIZE;
  134.     err = Inode_Read( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  135.     if (err)
  136.     { p->pos = NULL;
  137.       return err;
  138.     }
  139.     else
  140.       p->pos = p->buf;
  141.   }
  142.   return NULL;
  143. }
  144.  
  145. static _kernel_oserror *dir_add( DIR *p, int inode, char *name )
  146. { int off,len;
  147.   _kernel_oserror *err;
  148.   DEBUGf("dir_add(%p,%d,%s)\n",p,inode,name);
  149.   off = p->len % DIRPAGESIZE;
  150.   if (p->len-off!=p->off)
  151.   { p->off = p->len-off;
  152.     err = Inode_Read( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  153.     if (err)
  154.       return err;
  155.   }
  156.   p->pos = &p->buf[off];
  157.   len = DLEN(strlen(name));
  158.   if (off+len>DIRPAGESIZE-4)
  159.   { DINODE(p) = DIRPAGEMARK;
  160.     p->len += DIRPAGESIZE - off + len;
  161.     err = Inode_EnsureSize(p->inode,p->len);
  162.     if (!err)
  163.       err = Inode_Write( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  164.     if (err)
  165.       return err;
  166.     p->off += DIRPAGESIZE;
  167.     p->pos = p->buf;
  168.   }
  169.   else
  170.   { p->len += len;
  171.     err = Inode_EnsureSize(p->inode,p->len);
  172.     if (err)
  173.       return err;
  174.   }
  175.   DINODE(p)=inode;
  176.   strcpy(DNAME(p),name);
  177.   p->inode->d.length=p->len;
  178.   Inode_Changed(p->inode);
  179.   err = Inode_Write( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  180.   return err;
  181. }
  182.  
  183. static _kernel_oserror *dir_del( DIR *p )
  184. { int n;
  185.   _kernel_oserror *err;
  186.   if (!p->pos)
  187.     return ERR(mb_enddir);
  188.   n=DLEN(strlen(DNAME(p)));
  189.   DEBUGf("dir_del(%p)\n",p);
  190.   memcpy(p->pos,p->pos+n,&p->buf[DIRPAGESIZE]-p->pos-n);
  191.   if (p->len-p->off<=DIRPAGESIZE)
  192.   { p->len-=n;
  193.     p->inode->d.length=p->len;
  194.     Inode_Changed(p->inode);
  195.   }
  196.   err = Inode_Write( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  197.   if (err)
  198.     return err;
  199.   if (p->pos==p->buf && DINODE(p)==DIRPAGEMARK) /* dead page */
  200.   { if (p->off+DIRPAGESIZE<p->len) /* not last page */
  201.     { while (p->off+DIRPAGESIZE<p->len)
  202.       { err = Inode_Read( p->inode, p->off+DIRPAGESIZE, (p->len-p->off-DIRPAGESIZE)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off-DIRPAGESIZE), p->buf );
  203.         if (!err)
  204.           err =Inode_Write( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  205.         if (err) return err;
  206.         p->off += DIRPAGESIZE;
  207.       }
  208.       p->len -= DIRPAGESIZE;
  209.     }
  210.     else
  211.     { p->len = p->off;
  212.       if (p->off)
  213.       { p->off-=DIRPAGESIZE;
  214.         err = Inode_Read( p->inode, p->off, (p->len-p->off)>DIRPAGESIZE?DIRPAGESIZE:(p->len-p->off), p->buf );
  215.         if (err) return err;
  216.         p->pos = p->buf;
  217.         while (DINODE(p)!=DIRPAGEMARK)
  218.           p->pos+=DLEN(strlen(DNAME(p)));
  219.         p->len-=DIRPAGESIZE-(p->pos-p->buf);
  220.       }
  221.     }
  222.     err = Inode_EnsureSize(p->inode,p->len);
  223.     if (err) return err;
  224.     p->inode->d.length = p->len;
  225.     Inode_Changed(p->inode);
  226.   }
  227.   return NULL;
  228. }
  229.  
  230. /*  FileEntry module */
  231.  
  232. struct FileEntry
  233. {       INODE   *inode;
  234.         char    name[FILENAMELEN+1];
  235. };
  236.  
  237. static FileEntry *inodeFileEntry( INODE *d, char *name )
  238. {
  239.   FileEntry *fe;
  240.   fe=malloc( sizeof( FileEntry ) );
  241.   DEBUGf("Wrapped %p(%s) as %p context %p mode ??\n",d,name,fe,&fe /*, _kernel_processor_mode() */);
  242.   if ( !fe )
  243.     return NULL;
  244.   fe->inode = d;
  245.   strcpy( fe->name, name );
  246.   return fe;
  247. }
  248.  
  249. void *private_word;
  250.  
  251. _kernel_oserror * Initialise_FileEntrys( void *privw )
  252. {
  253.   _kernel_oserror *err=Inode_Init();
  254.   private_word = privw;
  255.   if (!err)
  256.   { enableticking=1;
  257.     setcallafter(privw);
  258.   }
  259.   return err;
  260. }
  261.  
  262. static INODE *find_root(char *volname)
  263. {
  264.   storeid s = Store_Find(special_field,volname);
  265.   INODE *inode = Inode_Find(s,1);
  266.   return inode;
  267. }
  268.  
  269. _kernel_oserror *FileEntry_FreeSpace( FileEntry *fe, struct freespace *b )
  270. {
  271.   return Store_FreeSpace(fe->inode->store,b);
  272. }
  273.  
  274. void Terminate_FileEntrys( void )
  275. {
  276.   ShutDown_FileEntrys();
  277. }
  278.  
  279. void ShutDown_FileEntrys( void )
  280. {
  281.   killticking(private_word);
  282.   Inode_Finish();
  283. }
  284.  
  285. _kernel_oserror *DoCommand( int cmd_no, int argc, char *argv[] )
  286. {
  287.   _kernel_swi_regs r;
  288.   argc = argc;
  289.   /*
  290.           Switch between the commands
  291.   */
  292.   switch ( cmd_no )
  293.   {
  294.   case 0: /*      *FSname       */
  295.  
  296.           r.r[0] = FSControl_SelectFilingSystem;
  297.           r.r[1] = ( int )FilingSystemName;
  298.           return _kernel_swi( XOS_Bit | OS_FSControl, &r, &r );
  299.   case 1:
  300.           return reportusage( argc>0?argv[1]:"" );
  301.   default:
  302.           return ERR( mb_BadParameters );
  303.   }
  304. }
  305.  
  306. /*
  307.         This is the SWI handler
  308. */
  309. _kernel_oserror *fs_swi
  310. ( 
  311.         int swi_number, 
  312.         _kernel_swi_regs *r, 
  313.         void *private_word
  314.  )
  315. {
  316.         _kernel_oserror *err = NULL;
  317.  
  318.         r = r;
  319.         private_word = private_word;
  320.  
  321.         switch ( swi_number )
  322.         {
  323.         default:
  324.                 err = NULL;
  325.                 break;
  326.         }
  327.  
  328.         return err;
  329. }
  330.  
  331. static char *popnode( char *name, char *buf )
  332. {
  333.   char *p;
  334.   int n;
  335.   p=strchr( name, '.' );
  336.   n=p?p-name:strlen( name );
  337.   if ( n>FILENAMELEN )
  338.     return ( char * )-1;
  339.   strncpy( buf, name, n );
  340.   buf[n]=0;
  341.   if ( p )
  342.     ++p;
  343.   return p;
  344. }
  345.  
  346. _kernel_oserror *FileEntry_DirScan( FileEntry *dir, int i, FileDesc *d, char **name )
  347. { INODE *h;
  348.   DIR *x;
  349.   _kernel_oserror *err;
  350.   static char namebuf[FILENAMELEN];
  351.   DEBUGf("FileEntry_DirScan(%s[%d],%d)\n",dir->name,dir->inode->uses,i);
  352.   if ( dir->inode->d.type!=2 )
  353.     return ERR( mb_NotADir );
  354.   for ( x = dir_open(dir->inode); x && DMORE(x); )
  355.   { if ( !i-- )
  356.     { h = Inode_Find( dir->inode->store, DINODE( x ) );
  357.       if (!h)
  358.       { dir_close(x); return ERR(mb_Lostinode); }
  359.       *d = h->d;
  360.       Inode_Lose(h);
  361.       *name = namebuf;
  362.       strcpy(namebuf,DNAME( x ));
  363.       return dir_close(x);
  364.     }
  365.     err = dir_next(x);
  366.     if (err) return err;
  367.   }
  368.   dir_close(x);
  369.   return ERR(mb_FileNotFound);
  370. }
  371.  
  372. _kernel_oserror *FileEntry_Find( FileEntry *fe, char *name, FileDesc *d )
  373. { _kernel_oserror *err;
  374.   FileEntry *ofe;
  375.   DEBUGf("FileEntry_Find(%s[%d],%s)\n",FileEntry_Name(fe),fe?fe->inode->uses:42,name);
  376.   normalise( &fe, &name );
  377.   err = FileEntry_Open( fe, name, OPENIN, &ofe );
  378.   if ( err )
  379.     return err;
  380.   *d = FileEntry_Desc( ofe );
  381.   return FileEntry_Close( ofe );
  382. }
  383.  
  384. static _kernel_oserror *finddirentry( INODE*dir, char *name, WHICH which, INODE **rh, DIR **where );
  385.  
  386. _kernel_oserror *FileEntry_Open(FileEntry *dfe, char *name, WHICH which, FileEntry **rfe )
  387. {
  388.   INODE *rh,*dir;
  389.   char *dname;
  390.   DIR *w;
  391.   _kernel_oserror *err;
  392.   DEBUGf("FileEntry_Open(%s[%d],%s,%d)\n",FileEntry_Name(dfe),dfe?dfe->inode->uses:42,name,which);
  393.   normalise( &dfe, &name );
  394.   if (!dfe)
  395.   { dir=find_root(NULL);
  396.     if (!dir)
  397.       return ERR( mb_FileNotFound );
  398.     dname="$";
  399.   }
  400.   else
  401.   { dir=Inode_Dup(dfe->inode);
  402.     dname=dfe->name;
  403.   }
  404.   if ( !name || !name[0] )
  405.   { *rfe=inodeFileEntry(dir,dname);
  406.     if (!*rfe)
  407.     { Inode_Lose(dir); return ERR(mb_malloc_failed); }
  408.     return NULL;
  409.   }
  410.   err = finddirentry( dir, name, OPENIN, &rh, &w );
  411.   if ( which<OPENIN )
  412.   { if ( err )
  413.     { rh = Inode_New(dir);
  414.       if (!rh)
  415.       { Inode_Lose(dir); return ERR(mb_malloc_failed); }
  416.       if (which==CREATEDIR)
  417.       { rh->d.type = 2;
  418.         StampInfo(&rh->d.info);
  419.         Inode_Changed(rh);
  420.       }
  421.       err = finddirentry( dir, name, which, &rh, &w );
  422.       if (err)
  423.         Inode_Delete(rh);
  424.     }
  425.   }
  426.   Inode_Lose(dir);
  427.   if ( err )
  428.   { *rfe = NULL;
  429.     return err;
  430.   }
  431.   if ( which==CREATE )
  432.   { if ( rh->d.type==2 )
  433.     {
  434.       *rfe=NULL;
  435.       Inode_Lose(rh);
  436.       dir_close(w);
  437.       return ERR(mb_NotAFile);
  438.     }
  439.     else
  440.     { rh->d.length = 0;
  441.       Inode_Changed(rh);
  442.     }
  443.   }
  444.   else if ( which==CREATEDIR )
  445.   { if ( rh->d.type == 2 )
  446.     {
  447.     }
  448.     else
  449.     { *rfe=NULL;
  450.       Inode_Lose(rh);
  451.       dir_close(w);
  452.       return ERR(mb_NotADir);
  453.     }
  454.   }
  455.   *rfe = inodeFileEntry( rh, w?DNAME( w ):"$" );
  456.   dir_close(w);
  457.   if (!*rfe)
  458.   { Inode_Lose(rh); return ERR(mb_malloc_failed); }
  459.   return NULL;
  460. }
  461.  
  462. /* if (create), add entry else find one
  463.  * return position where found in where, or NULL for root
  464.  */
  465.  
  466. static _kernel_oserror *finddirentry( INODE *dir, char *name, WHICH which, INODE **rh, DIR **where ) 
  467. {
  468.   char buf[100];
  469.   INODE *h,*inode;
  470.   DIR *x;
  471.   _kernel_oserror *err;
  472.   DEBUGf("finddirentry(%p[%d],%s,%d)\n",dir,dir?dir->uses:42,name,which);
  473.   if ( !dir )
  474.   { dir=find_root(NULL);
  475.     if (!dir)
  476.       return ERR( mb_FileNotFound );
  477.   }
  478.   else
  479.     dir = Inode_Dup(dir);
  480.   switch( name[0] )
  481.   {
  482.   case '$':
  483.     Inode_Lose(dir);
  484.     if (name[1] && name[1]!='.')
  485.       return ERR( mb_FileNotFound );
  486.     dir=find_root(NULL);
  487.     if (!dir)
  488.       return ERR( mb_FileNotFound );
  489.     if ( !name[1] )
  490.     {
  491. returnroot:
  492.         inode=Inode_Dup(dir);
  493.         x=NULL;
  494.         goto returninode;
  495.     }
  496.     name+=2;
  497.     break;
  498.   case ':':
  499.     name=popnode( name+1, buf );
  500.     Inode_Lose(dir);
  501.     dir=find_root(buf);
  502.     if (!dir)
  503.       return ERR( mb_FileNotFound );
  504.     if ( !name )
  505.       goto returnroot;
  506.     if ( name[0]=='$' )
  507.     { if (!name[1])
  508.         goto returnroot;
  509.       else if (name[1]!='.')
  510.       { Inode_Lose(dir); return ERR( mb_FileNotFound ); }
  511.       name+=2;
  512.     }
  513.     break;
  514.   }
  515. searchinode:
  516.   if ( dir->d.type!=2 )
  517.   { Inode_Lose(dir); return ERR( mb_NotADir ); }
  518.   name = popnode( name, buf );
  519.   if ( name==( char * )-1 )
  520.     { Inode_Lose(dir); return ERR( mb_LongName ); }
  521.   if ( buf[0]=='^' && !buf[1] )
  522.   {
  523.     if (dir->inode==1)
  524.     { inode = Inode_Dup(dir);
  525.       x = NULL;
  526.       goto foundobj;
  527.     }
  528.     inode = Inode_Find( dir->store,dir->parentinode );
  529.     if ( !inode )
  530.       { Inode_Lose(dir); return ERR( mb_Lostinode ); }
  531.     h = Inode_Find( inode->store,inode->parentinode );
  532.     if ( !h )
  533.     { Inode_Lose(inode); Inode_Lose(dir); return ERR( mb_Lostinode ); }
  534.     for ( x = dir_open( h ); x && DMORE(x); )
  535.     { if ( DINODE( x )==inode->inode )
  536.       { Inode_Lose(h);
  537.         goto foundobj;
  538.       }
  539.       err = dir_next(x);
  540.       if (err) return err;
  541.     }
  542.     dir_close(x);
  543.     Inode_Lose(inode);
  544.     Inode_Lose(h);
  545.     Inode_Lose(dir); 
  546.     return ERR( mb_FileNotFound );
  547.   }
  548.   for ( x = dir_open( dir ); x && DMORE(x); )
  549.   { if ( !stricmp( DNAME( x ), buf ) )
  550.       { inode = Inode_Find( dir->store,DINODE(x) );
  551.         if (!inode)
  552.         { dir_close(x); Inode_Lose(dir); return ERR( mb_Lostinode ); }
  553. foundobj:
  554.         if ( name )
  555.         { Inode_Lose(dir);
  556.           dir=inode;
  557.           dir_close(x); 
  558.           goto searchinode;
  559.         }
  560.         if ( which<OPENIN )
  561.         { dir_close(x); Inode_Lose(dir); Inode_Lose(inode); return ERR(mb_AlreadyExists); }
  562.         goto returninode;
  563.       }
  564.     err = dir_next(x);
  565.     if (err) return err;
  566.   }
  567.   if ( which>=OPENIN || name )
  568.   { dir_close(x); Inode_Lose(dir); return ERR( mb_FileNotFound ); }
  569.   inode = *rh;
  570.   err = dir_add( x, inode->inode, buf );
  571.   if (err) return err;
  572.   inode->parentinode = dir->inode;
  573.   Inode_Changed(inode);
  574. returninode:
  575.   Inode_Lose(dir);
  576.   *rh=inode;
  577.   *where=x;
  578.   return NULL;
  579. }
  580.  
  581. _kernel_oserror *FileEntry_Close( FileEntry *fe )
  582. {
  583.   DEBUGf("FileEntry_Close(%s)[%d]\n",FileEntry_Name(fe),fe?fe->inode->uses:42);
  584.   if ( fe )
  585.   { Inode_Lose(fe->inode);
  586.     free( fe );
  587.   }
  588.   return NULL;
  589. }
  590.  
  591. _kernel_oserror *FileEntry_Delete( FileEntry *dir, char *name, FileDesc *d )
  592. {
  593.   INODE *h,*dh;
  594.   DIR *w;
  595.   _kernel_oserror *err;
  596. #ifdef DEBUG
  597.   printf( " Delete dir=%s[%d] name=%s\n", FileEntry_Name(dir),dir?dir->inode->uses:42, name?name:"NULL" );
  598. #endif
  599.   normalise( &dir, &name );
  600.   if ( !name )
  601.     return ERR( mb_ObjectInUse );
  602.   if (!dir)
  603.   { dh=find_root(NULL);
  604.     if (!dh)
  605.       return ERR( mb_FileNotFound );
  606.   }
  607.   else
  608.     dh=Inode_Dup(dir->inode);
  609.   err = finddirentry( dh, name, OPENIN, &h, &w );
  610.   Inode_Lose(dh);
  611.   if ( err )
  612.     return err;
  613. #ifdef DEBUG
  614.   printf( " Delete h=%p\n", h );
  615. #endif
  616.   if ( h->d.attr&Attr_L )
  617.   { Inode_Lose(h); dir_close(w); return ERR( mb_Locked ); }
  618.   if ( h->d.type==2 && h->d.length>0 || !w )
  619.   { Inode_Lose(h); dir_close(w); return ERR( mb_DirNotEmpty ); }
  620.   *d = h->d;
  621.   Inode_Delete(h);
  622.   dir_del(w);
  623.   dir_close(w); 
  624.   return NULL;
  625. }
  626.  
  627. _kernel_oserror *FileEntry_Rename( FileEntry *dir, char *name, FileEntry *newdir, char *newname )
  628. {
  629.   INODE *h;
  630.   DIR *w1,*w2;
  631.   _kernel_oserror *err;
  632.   DEBUGf("FileEntry_Rename(%s[%d],%s,%s[%d],%s)\n",dir->name,dir?dir->inode->uses:42,name,newdir->name,newdir?newdir->inode->uses:42,newname);
  633.   normalise( &dir, &name );
  634.   normalise( &newdir, &newname );
  635.   err = finddirentry( dir?dir->inode:NULL, name, OPENIN, &h, &w1 );
  636.   if ( err )
  637.     return err;
  638.   if ( h->d.attr&Attr_L || !w1 )
  639.   { Inode_Lose(h); dir_close(w1); return ERR( mb_Locked ); }
  640.   err = finddirentry( newdir?newdir->inode:NULL, newname, CREATE, &h, &w2 );
  641.   if ( err )
  642.   { Inode_Lose(h); dir_close(w1); return err; }
  643.   if ( !w2 || w1->inode->store != w2->inode->store )
  644.   { Inode_Lose(h); dir_close(w1); return ERR(mb_BadRename); }
  645.   if (w1->inode==w2->inode)
  646.   { dir_close(w1);
  647.     dir_close(w2);
  648.     Inode_Lose(h);
  649.     err = finddirentry( dir?dir->inode:NULL, name, OPENIN, &h, &w1 );
  650.     if ( err )
  651.       return err;
  652.   }
  653.   else
  654.     dir_close(w2);
  655.   Inode_Lose(h);
  656.   dir_del(w1);
  657.   dir_close(w1);
  658.   return NULL;
  659. }
  660.  
  661. _kernel_oserror *FileEntry_GetBytes( FileEntry *fe, char *p, int o, int n, int *newpos, int *len )
  662. {
  663.   DEBUGf("FileEntry_GetBytes(%s[%d],%p,%d,%d)\n",FileEntry_Name(fe),fe?fe->inode->uses:42,p,o,n);
  664.   *newpos = o+n; *len = n;
  665.   return Inode_Read( fe->inode, o, n, p );
  666. }
  667.  
  668. _kernel_oserror * FileEntry_GetByte( FileEntry *fe, int *b )
  669. {
  670.   fe = fe;
  671.   b = b;
  672.   return ERR(mb_BadParameters);
  673. }
  674.  
  675. _kernel_oserror *FileEntry_PutBytes( FileEntry *fe, char *p, int o, int n, int *newpos )
  676. { _kernel_oserror *err;
  677.   DEBUGf("FileEntry_PutBytes(%s[%d],%p,%d,%d)\n",FileEntry_Name(fe),fe?fe->inode->uses:42,p,o,n);
  678.   *newpos = n+o;
  679.   if ( n+o>fe->inode->d.length )
  680.   { if ( ( err = FileEntry_SetLength( fe, n+o ) )!=NULL )
  681.       return err;
  682.   }
  683.   if ( n )
  684.   { err = Inode_Write( fe->inode, o, n, p );
  685.     o+=n;
  686.     return err;
  687.   }
  688.   return NULL;
  689. }
  690.  
  691. _kernel_oserror *FileEntry_PutByte( FileEntry *fe , int c )
  692. {
  693.   fe = fe;
  694.   c = c;
  695.   return ERR(mb_BadParameters);
  696. }
  697.  
  698. static char zero[512];
  699.  
  700. _kernel_oserror *FileEntry_PutZeros( FileEntry *fe, int o, int n )
  701. { _kernel_oserror *err=NULL;
  702.   DEBUGf("FileEntry_PutZeros(%s[%d],%d,%d)\n",FileEntry_Name(fe),fe?fe->inode->uses:42,o,n);
  703.   if ( n+o>fe->inode->d.length )
  704.   { if ( ( err = FileEntry_SetLength( fe, n+o ) )!=NULL )
  705.       return err;
  706.   }
  707.   while ( n>512 )
  708.   { err=Inode_Write( fe->inode, o, 512, zero );
  709.     o+=512; n-=512;
  710.   }
  711.   if (n)
  712.   { err=Inode_Write( fe->inode, o, n, zero );
  713.     o+=n;
  714.   }
  715.   return NULL;
  716. }
  717.  
  718. _kernel_oserror *FileEntry_EnsureSize( FileEntry *fe, int size )
  719. {
  720.   DEBUGf("FileEntry_EnsureSize(%s[%d],%d)\n",FileEntry_Name(fe),fe?fe->inode->uses:42,size);
  721.   if ( size <= fe->inode->allocated )
  722.     return NULL;
  723.   return Inode_EnsureSize( fe->inode, size );
  724. }
  725.  
  726. _kernel_oserror *FileEntry_SetLength( FileEntry *fe, int length )
  727. { _kernel_oserror *err;
  728.   DEBUGf("FileEntry_SetLength(%s[%d],%d)\n",FileEntry_Name(fe),fe?fe->inode->uses:42,length);
  729.   if ( NULL!=( err=FileEntry_EnsureSize( fe, length ) ) )
  730.     return err;
  731.   fe->inode->d.length = length;
  732.   Inode_Changed( fe->inode );
  733.   return NULL;
  734. }
  735.  
  736. _kernel_oserror *FileEntry_Access( FileEntry *dir, char *name, int attr )
  737. { FileEntry *fe;
  738.   _kernel_oserror *err;
  739.   DEBUGF("Access %s[%d] %s %x\n",FileEntry_Name(dir),dir?dir->inode->uses:42,name?name:"NULL",attr);
  740.   err = FileEntry_Open(dir,name,OPENIN,&fe);
  741.   if (err)
  742.     return err;
  743.   fe->inode->d.attr = attr;
  744.   Inode_Changed( fe->inode );
  745.   FileEntry_Close(fe);
  746.   return NULL;
  747. }
  748.  
  749. _kernel_oserror *FileEntry_SetInfo( FileEntry *fe, Information_Fields info )
  750. {
  751.   DEBUGf("FileEntry_SetInfo(%s)[%d]\n",FileEntry_Name(fe),fe->inode->uses);
  752.   fe->inode->d.info = info;
  753.   Inode_Changed( fe->inode );
  754.   return NULL;
  755. }
  756.  
  757. _kernel_oserror *FileEntry_Flush ( FileEntry *fe )
  758. {
  759.   DEBUGf("FileEntry_Flush(%s)[%d]\n",FileEntry_Name(fe),fe?fe->inode->uses:42);
  760.   return NULL;
  761. }
  762.  
  763. _kernel_oserror *FileEntry_SetSeqPtr( FileEntry *fe , int seqptr )
  764. {
  765.   DEBUGf("FileEntry_SetSeqPtr(%s)[%d] %d\n",FileEntry_Name(fe),fe?fe->inode->uses:42,seqptr);
  766.   return ERR(mb_BadParameters);
  767. }
  768.  
  769. void FileEntry_FileInfoObject
  770. ( 
  771.   FileEntry *fse
  772.  )
  773. {
  774.   DEBUGf("FileEntry_FileInfoObject(%s)[%d]\n",FileEntry_Name(fse),fse?fse->inode->uses:42);
  775.   printf( "%-20s %8p %8p %8x %8x %7p %7p %7x %d\n\r", 
  776.            fse->name, 
  777.            fse->inode->d.info.load_exec.load_address, 
  778.            fse->inode->d.info.load_exec.execute_address, 
  779.            fse->inode->d.length, 
  780.            fse->inode->d.attr, 
  781.            fse, 
  782.            fse->inode, 
  783.            fse->inode->allocated, 
  784.            fse->inode->uses );
  785. }
  786.  
  787. char *FileEntry_DiscName( FileEntry *fe )
  788. {
  789.   DEBUGf("FileEntry_DiscName(%s)[%d]\n",FileEntry_Name(fe),fe?fe->inode->uses:42);
  790.   if (!fe)
  791.     return "\"Unset\"";
  792.   return Store_Name(fe->inode->store);
  793. }
  794.  
  795. char *FileEntry_SpecialField( FileEntry *fe )
  796. {
  797.   DEBUGf("FileEntry_SpecialField(%s)[%d]\n",FileEntry_Name(fe),fe?fe->inode->uses:42);
  798.   if (!fe)
  799.     return NULL;
  800.   return Store_SpecialField(fe->inode->store);
  801. }
  802.  
  803. char *FileEntry_Name( FileEntry *fe )
  804. {
  805.   return fe?fe->name:"\"Unset\"";
  806. }
  807.  
  808. FileDesc FileEntry_Desc( FileEntry *fe )
  809. {
  810.   DEBUGf("FileEntry_Desc(%s)[%d]\n",FileEntry_Name(fe),fe?fe->inode->uses:42);
  811.   return fe->inode->d;
  812. }
  813.  
  814. int FileEntry_SeqPtr( FileEntry *fe )
  815. {
  816.   DEBUGf("FileEntry_SeqPtr(%s)[%d]\n",FileEntry_Name(fe),fe?fe->inode->uses:42);
  817.   return -1;
  818. }
  819.  
  820. int FileEntry_Allocated( FileEntry *fe )
  821. { return fe->inode->allocated;
  822. }
  823.